package com.csb.service.impl;

import com.csb.config.ErrorForbiddenException;
import com.csb.config.ErrorRegisterException;
import com.csb.config.MyConstants;
import com.csb.mapper.AssetMapper;
import com.csb.mapper.UserMapper;
import com.csb.pojo.AddUserRole;
import com.csb.pojo.UserInfo;
import com.csb.service.UserService;
import com.csb.util.MD5;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UnknownAccountException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {
    // 依赖
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private AssetMapper assetMapper;

    // 格式化时间字符串
    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     * 根据账号,查找该用户信息
     * @param account
     * @return
     */
    @Override
    @Cacheable(value = "getUserInfoByAccount")
    public UserInfo getUserInfoByAccount(String account) {
        // 根据账号,查找该用户信息
        UserInfo userInfoByAccount = userMapper.getUserInfoByAccount(account);
        if (userInfoByAccount == null){
            // 声明账号异常
            throw new UnknownAccountException();
        }
        // 根据账号信息判断是否可以登录
        if (userInfoByAccount.getIsLogin()==MyConstants.USER_LOGIN_NO){
            // 声明注册异常
            throw new ErrorRegisterException();
        }
        // 根据账号信息判断是否可以登录
        if (userInfoByAccount.getIsShow()==MyConstants.USER_SHOW_NO){
            // 声明禁用异常
            throw new ErrorForbiddenException();
        }
        // 返回用户信息
        return userInfoByAccount;
    }


    /**
     * 申请账号
     * @param userInfo
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addUserInfo(UserInfo userInfo) {
        // 获取时间
        Date date = new Date();
        // 设置申请时间
        userInfo.setCreationTime(simpleDateFormat.format(date));
        // 设置登录状态
        userInfo.setIsLogin(MyConstants.USER_LOGIN_NO);
        // 设置显示状态
        userInfo.setIsShow(MyConstants.USER_SHOW_NO);
        // 返回 申请账号
        try {
            // 同意用户的申请
            userMapper.addUserInfo(userInfo);
            Integer id = userMapper.selectUserId(userInfo.getAccount());
            // 声明AddUserRole对象
            AddUserRole addUserRole = new AddUserRole();
            // 设置属性
            addUserRole.setId(id);
            // 设置角色信息
            addUserRole.setRid(MyConstants.USER_ROLE_USER);
            // 设置用户的权限
            userMapper.userAddRole(addUserRole);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            // 手动回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

    }

    /**
     * 验证账号是否重复
     * @param account
     * @return
     */
    @Override
    public boolean chkAccount(String account) {
        return userMapper.chkAccount(account)>0;
    }

    /**
     * 获取账号申请列表
     * @return
     */
    @Override
    @Cacheable(value = "userList",key = "'getAroUserList'")
    public List<UserInfo> getAroUserList() {
        return userMapper.getAroUserList(MyConstants.USER_LOGIN_NO,MyConstants.USER_SHOW_NO);
    }

    /**
     * 同意账号的申请
     * @param ids 账号的id
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean userAroYes(Integer[] ids) {
        try {
            userMapper.userAroYes(ids,MyConstants.USER_LOGIN_YES,MyConstants.USER_SHOW_YES);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            // 手动回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }
    }
    /**
     * 不同意账号的申请
     * @param ids 账号的id
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean userAroNo(Integer[] ids) {
        try {
            // 不同意用户的申请
            userMapper.userAroNo(ids);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            // 手动回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }
    }

    /**
     * 获取所有账号列表
     * @return
     */
    @Override
    @Cacheable(value = "allUserInfo")
    public List<UserInfo> findAllUserInfo() {
        return userMapper.findAllUserInfo(MyConstants.USER_LOGIN_YES);
    }

    /**
     * 禁用或者启用账号
     * @param id
     * @param isShow
     * @return
     */
    @Override
    // @CacheEvict(value = "allUserInfo",allEntries = true)
    public String updateUserShowYesOrNo(Integer id, Integer isShow,String rName) {
        // 获取账号信息
        UserInfo userInfo = (UserInfo) SecurityUtils.getSubject().getPrincipal();
        // 获取用户角色信息
        String userRole = userInfo.getRolesList().getRName();
        // 判断 用户角色
        if (!rName.equals(userRole) && !MyConstants.ROLE_ADMIN.equals(rName)){
            // 判断 是禁用还是启用
            if (isShow==MyConstants.USER_SHOW_YES){
                userMapper.updateUserShowYesOrNo(id,MyConstants.USER_SHOW_YES);
                return "1";
            }else {
                userMapper.updateUserShowYesOrNo(id,MyConstants.USER_SHOW_NO);
                return "0";
            }
        }else {
            // 返回 没有权限
            return "-1";
        }
    }

    /**
     * 修改登陆时间
     * @param account
     */
    @Override
    public void updateUserCreationTime(String account) {
        // 获取时间
        Date date = new Date();
        // 设置申请时间
        String creationTime = simpleDateFormat.format(date);
        // 修改登陆时间
        userMapper.updateUserCreationTime(account, creationTime);
    }

    /**
     * 根据账号修改信息
     * @param userInfo
     * @return
     */
    @Override
    public boolean updateUserInfo(UserInfo userInfo) {
        return userMapper.updateUserInfo(userInfo)>0;
    }

    /**
     * 修改密码
     * @param userInfo
     * @return
     */
    @Override
    public boolean updateUserPwd(UserInfo userInfo) {
        String pwd = MD5.encrypt(userInfo.getPwd());
        userInfo.setPwd(pwd);
        return userMapper.updateUserPwd(userInfo)>0;
    }

    /**
     * 删除用户信息
     * @param id
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteUserInfo(Integer id) {
        try {
            // 删除用户信息
            userMapper.deleteUserInfo(id);
            // 删除用户对应的角色信息
            userMapper.deleteUserRole(id);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            // 手动回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }
    }

    /**
     * 检测账号
     * @param account
     * @return
     */
    @Override
    public boolean userUseAssetCount(String account) {
        return assetMapper.userUseAssetCount(account)>0;
    }

    /**
     * 上传头像
     * @param bytes
     * @param account
     * @return
     */
    @Override
    public int updateHeadProtrait(byte[] bytes, String account) {
        return userMapper.updateHeadProtrait(bytes,account);
    }

    /**
     * 修改权限
     * @param id
     * @return
     */
    @Override
    public boolean updateManagerNo(Integer id) {
        return userMapper.updateManager(id,MyConstants.USER_ROLE_USER)>0;
    }

    /**
     * 修改用户权限
     * @param id
     * @return
     */
    @Override
    public boolean updateManagerYes(Integer id) {
        return userMapper.updateManager(id,MyConstants.USER_ROLE_MANAGER)>0;
    }
}
